C:/Projekte/RAIS/ApplicationLogiLayer/TableManagement.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Transactions;
using System.Xml;

using RAIS.Common.DynamicMaskManagement;
using RAIS.Common.TableManagement;

using TableTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Table.TableTypeData>;
using FieldTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.FieldTypeData>;
using FieldSizes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.FieldSizeData>;
using NecessityTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.NecessityTypeData>;
using TableGroups = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.TableGroup>;
using Tables = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Table>;
using Fields = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field>;
using QueryTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Query.QueryTypeData>;
using Queries = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Query>;
using QueryParameterTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.QueryParameter.QueryParameterTypeData>;
//using QueryParameterTypes = System.Collections.Generic.Dictionary<RAIS.Common.TableManagement.QueryParameter.QueryParameterType, RAIS.Common.TableManagement.QueryParameter.QueryParameterTypeData>;
using QueryParameters = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.QueryParameter>;
using CustomizationTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Query.CustomizationType>;

namespace RAIS.ApplicationLogicLayer
{
    public class TableManagement
    {
                //*********************************************************************
                #region Public static methods






        public static bool IsEmptyFelds(string tableName, string fieldName)
        { 
            return DataAccessLayer.TableManagement.IsEmptyFelds(tableName, fieldName);
        }
        public static void InitializeDAL()
                {
                        new DataAccessLayer.TableManagement();
                }
        public static Tables GetCustomTablesByGroup(TableGroup tableGroup)
        {
            return RAIS.DataAccessLayer.TableManagement.GetCustomTablesByTableGroup(tableGroup);
        }
                public static Tables GetTablesByGroup(TableGroup tableGroup, bool showProtectors, bool showEvaluators)
                //public static Tables GetTablesByGroup(TableGroup tableGroup, bool designMode)
                {
                        return RAIS.DataAccessLayer.TableManagement.GetTablesByTableGroup(tableGroup, showProtectors, showEvaluators);
                        //return RAIS.DataAccessLayer.TableManagement.GetTablesByTableGroup(tableGroup, designMode);
                }
                public static Table GetTableByTableID(int id)
                {
                        return RAIS.DataAccessLayer.TableManagement.GetTableByTableID(id);
                }
                public static bool AddTable(Table table, TableGroup tableGroup, string maskName, int subcategoryID, DynamicMask.DynamicMaskType? dynamicMaskType, string dynamicMaskName, bool addForeignKeyField, bool createDymamicMask, ref string returnMessage)
        {
            return RAIS.DataAccessLayer.TableManagement.AddTable(table, tableGroup, maskName, subcategoryID, dynamicMaskType, dynamicMaskName, addForeignKeyField, createDymamicMask, ref returnMessage);
        }
        public static bool AddField(Table table, Field field, ref string returnMessage)
        {
            return RAIS.DataAccessLayer.TableManagement.AddField(table, field, ref returnMessage);
        }
        public static bool RemoveTable(Table table, ref string returnMessage)
        {
            return RAIS.DataAccessLayer.TableManagement.RemoveTable(table, ref returnMessage);
        }
        public static bool SaveCustomTable(Table table, ref string returnMessage)
        {
            using (TransactionScope ts = new TransactionScope())
            {
                bool success = true;
                foreach (Field field in table.RemovedFields.Values)
                {
                    if (!RemoveField(field, ref returnMessage))
                    {
                        success = false;
                        break;
                    }
                }

                if (success)
                {
                    foreach (Field field in table.AddedFields.Values)
                    {
                        if (!AddField(table, field, ref returnMessage))
                        {
                            success = false;
                            break;
                        }
                    }
                }

                if (success)
                {
                    returnMessage = RAIS.Common.Messages.MODIFICATIONS_SAVED;
                    table.Modified = false;
                    ts.Complete();
                }
                return success;
            }
        }
                public static bool SaveFieldOrder(Field field, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.SaveFieldOrder(field, ref returnMessage);
                }
                public static bool SaveFieldQueryName(Field field, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.SaveFieldQueryName(field, ref returnMessage);
                }
                public static bool SaveField(Field field, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.SaveField(field, ref returnMessage);
                }
        public static bool RemoveField(Field field, ref string returnMessage)
        {
            return RAIS.DataAccessLayer.TableManagement.RemoveField(field, ref returnMessage);
        }
                public static Fields GetLookupFieldsByTable(Table table)
                {
                        Fields fields = RAIS.DataAccessLayer.TableManagement.GetFieldsByTable(table);
                        Fields lookupFields = new Dictionary<string, Field>();

                        foreach (KeyValuePair<string, Field> kvp in fields)
                        {
                                Field field = kvp.Value;
                                if (field.IsLookupField)
                                        lookupFields.Add(kvp.Key, kvp.Value);
                        }
                        return lookupFields;
                }
                public static Fields GetTextFieldsByTable(Table table)
                {
                        Fields fields = RAIS.DataAccessLayer.TableManagement.GetFieldsByTable(table);
                        Fields lookupFields = new Dictionary<string, Field>();

                        foreach (KeyValuePair<string, Field> kvp in fields)
                        {
                                Field field = kvp.Value;
                                if (field.IsTextField)
                                        lookupFields.Add(kvp.Key, kvp.Value);
                        }
                        return lookupFields;
                }
        public static Fields GetFieldsByTable(Table table)
        {
            return RAIS.DataAccessLayer.TableManagement.GetFieldsByTable(table);
        }
                public static XmlDocument GetTableAndFieldXml()
                {
                        return RAIS.DataAccessLayer.TableManagement.GetTableAndFieldXml();
                }
                public static FieldSizes GetFieldSizesByFieldType(Field.FieldType fieldType)
                {
                        return RAIS.DataAccessLayer.TableManagement.GetFieldSizesByFieldType(fieldType);
                }
                public static Queries GetQueries()
                {
            return RAIS.DataAccessLayer.TableManagement.GetQueries();
                }
                public static Queries GetQueriesByCustomizationType(Query.CustomizationType customizationType)
                {
                        Query.QueryType queryType = Query.GetQueryTypeByCustomizationType(customizationType);
            return DataAccessLayer.TableManagement.GetQueriesByQueryType(queryType);
                }
                public static Queries GetQueriesByQueryType(Query.QueryType queryType)
                {
            return DataAccessLayer.TableManagement.GetQueriesByQueryType(queryType);
                }
                public static bool AddQuery(Query query, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.AddQuery(query, ref returnMessage);
                }
                public static bool SaveQuery(Query query, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.SaveQuery(query, ref returnMessage);
                }
                public static bool RemoveQuery(Query query, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.RemoveQuery(query, ref returnMessage);
                }
                public static bool ValidateQueryParameters(Query query, ref string returnMessage)
                {
                        bool success = true;
                        bool startDateExists = false;
                        bool endDateExists = false;
                        if (query != null)
                        {
                                foreach (KeyValuePair<string, QueryParameter> kvp in query.QueryParameters)
                                {
                                        QueryParameter parameter = kvp.Value;
                                        if (parameter.Type == QueryParameter.QueryParameterType.Unknown)
                                        {
                                                returnMessage = Common.Messages.QUERY_PARAMETER_UNKNOWN_EXISTS;
                                                success = false;
                                                break;
                                        }

                                        if (parameter.Type == QueryParameter.QueryParameterType.DatesRangeStartDate)
                                                startDateExists = true;
                                        if (parameter.Type == QueryParameter.QueryParameterType.DatesRangeEndDate)
                                                endDateExists = true;
                                }

                                if (startDateExists && !endDateExists
                                        || !startDateExists && endDateExists)
                                {
                                        returnMessage = Common.Messages.QUERY_PARAMETER_DATES_RANGE_ERROR;
                                        success = false;
                                }
                        }

                        return success;
                }
                public static bool CreateQuery(Query query, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.CreateQuery(query, ref returnMessage);
                }
                public static bool CheckQuery(Query query, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.CheckQuery(query, ref returnMessage);
                }
                public static QueryParameterTypes GetQueryParameterTypesByQuery(Query query)
                {
                        QueryParameterTypes allQueryParameterTypes = DataAccessLayer.TableManagement.QueryParameterTypes;
                        QueryParameterTypes queryParameterTypes = new Dictionary<string, QueryParameter.QueryParameterTypeData>();

                        if (query != null)
                        {
                                foreach (KeyValuePair<string, QueryParameter.QueryParameterTypeData> kvp in allQueryParameterTypes)
                                {
                                        QueryParameter.QueryParameterTypeData typeData = kvp.Value;
                                        if (query.QueryForFilters && typeData.ParameterTypeForFilters)
                                                queryParameterTypes.Add(kvp.Key, typeData);

                                        if (!query.QueryForFilters && typeData.ParameterTypeForOthers)
                                                queryParameterTypes.Add(kvp.Key, typeData);
                                }
                        }

                        return queryParameterTypes;
                }
                public static QueryParameters GetQueryParametersByQuery(Query query)
                {
                        return DataAccessLayer.TableManagement.GetQueryParametersByQuery(query);
                }
                public static bool AddQueryParameter(Query query, QueryParameter queryParameter, ref string returnMessage)
                {
                        return DataAccessLayer.TableManagement.AddQueryParameter(query, queryParameter, ref returnMessage);
                }
                public static bool SaveQueryParameter(QueryParameter queryParameter, ref string returnMessage)
                {
                        return DataAccessLayer.TableManagement.SaveQueryParameter(queryParameter, ref returnMessage);
                }
                public static bool SaveQueryParameterOrder(QueryParameter queryParameter, ref string returnMessage)
                {
                        return DataAccessLayer.TableManagement.SaveQueryParameterOrder(queryParameter, ref returnMessage);
                }
                public static bool RemoveQueryParameter(QueryParameter queryParameter, ref string returnMessage)
                {
                        return DataAccessLayer.TableManagement.RemoveQueryParameter(queryParameter, ref returnMessage);
                }
                public static CustomizationTypes GetCustomizationTypes()
                {
                        CustomizationTypes types = new Dictionary<string, Query.CustomizationType>();

                        types.Add("List With Filter Mask", Query.CustomizationType.ListWithFilter);
                        types.Add("Query Report", Query.CustomizationType.QueryReport);
                        types.Add("Statistics Report", Query.CustomizationType.StatisticsReport);
                        types.Add("Consistency Check", Query.CustomizationType.ConsistencyCheck);
                        types.Add("Dynamic Mask Field", Query.CustomizationType.EntryFilter);
            types.Add("RAN Autogeneration", Query.CustomizationType.RanAutogeneration);

                        return types;
                }
                public static bool CreateHistoryTable(Table table, ref string returnMessage)
                {
                        return RAIS.DataAccessLayer.TableManagement.CreateHistoryTable(table, ref returnMessage);
                }
                public static List<string> GetQueryAssignedObjectsNames(Query query)
                {
                        return DataAccessLayer.TableManagement.GetQueryAssignedObjectsNames(query);
                }
        public static bool IsTableContainData(Table table)
        {
            return DataAccessLayer.TableManagement.IsTableContainData(table);
        }
        #endregion
                //*********************************************************************
                #region Properties

        public static FieldTypes FieldTypes
        {
            get { return RAIS.DataAccessLayer.TableManagement.FieldTypes; }
        }
        public static FieldSizes FieldSizes
        {
            get { return RAIS.DataAccessLayer.TableManagement.FieldSizes; }
        }
                public static NecessityTypes NecessityTypes
                {
                        get { return RAIS.DataAccessLayer.TableManagement.NecessityTypes; }
                }
        public static TableTypes TableTypes
        {
            get { return RAIS.DataAccessLayer.TableManagement.TableTypes; }
        }
        public static TableGroups TableGroups
        {
            get { return RAIS.DataAccessLayer.TableManagement.TableGroups; }
        }
                public static Tables AllTables
                {
                        get { return RAIS.DataAccessLayer.TableManagement.AllTables; }
                }
                public static QueryTypes QueryTypes
                {
                        get { return RAIS.DataAccessLayer.TableManagement.QueryTypes; }
                }
                //\brief This property retrieves a list of all available query parameter types. 

                //\return Dictionary of query parameter type names vs query parameter type objects
                //\warning Addressing this property casues an MS SQL query. 
                //         Use is for initialising a local variable instead of addressing it iteratively.
                //*/
                //public static QueryParameterTypes QueryParameterTypes
                //{
                //    get { return RAIS.DataAccessLayer.TableManagement.QueryParameterTypes; }
                //}
                #endregion
    }
}